home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / bn_bighop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  34.5 KB  |  1,295 lines
  1. /*****************************************************************************
  2.   FILE           : bn_bighop.c
  3.   SHORTNAME      : bn_bighop
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Creates the Hopfield BIGNET-window. 
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Christine Bagdi  
  10.   DATE           : 27.5.1993
  11.  
  12.   CHANGED BY     : 
  13.   IDENTIFICATION : @(#)bn_bignet.c    1.10 4/26/93
  14.   SCCS VERSION   : 1.10
  15.   LAST CHANGE    : 
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20.  
  21. #include <stdlib.h>
  22. #include <stdio.h>
  23. #include <X11/Xlib.h>
  24. #include <X11/Xutil.h>
  25. #include <X11/Xos.h>
  26. #include <X11/cursorfont.h>
  27. #include <X11/Intrinsic.h>
  28. #include <X11/StringDefs.h>
  29. #include <X11/Shell.h>
  30. #include <X11/Xaw/Box.h>
  31. #include <X11/Xaw/Simple.h>
  32. #include <X11/Xaw/Grip.h>
  33. #include <X11/Xaw/Form.h>
  34. #include <X11/Xaw/SmeBSB.h>
  35. #include <X11/Xaw/SmeLine.h>
  36. #include <X11/Xaw/Viewport.h>
  37. #include <X11/Xaw/Label.h>
  38. #include <X11/Xaw/Toggle.h>
  39. #include <X11/Xaw/Command.h>
  40. #include <X11/Xaw/Cardinals.h>
  41. #include <X11/Xaw/AsciiText.h>
  42. #include <X11/Xaw/Scrollbar.h>
  43.  
  44. #include "ui.h"
  45. #include "glob_typ.h"
  46. #include "kr_ui.h"
  47. #include "ui_mainP.h"
  48. #include "ui_confirmer.h"
  49. #include "ui_textP.h"
  50. #include "ui_utilP.h"
  51. #include "ui_netUpdate.h"
  52.  
  53. #include "ui_status.h"
  54. #include "ui_xWidgets.h"
  55. #include "ui_fileP.h"
  56. #include "ui_display.h"
  57. #include "ui_event.h"
  58. #include "ui_selection.h"
  59. #include "ui_action.h"
  60. #include "bn_basics.h"
  61.  
  62.  
  63. #include "bn_bighop.ph"
  64.  
  65.  
  66. /*************************************************************************
  67.  
  68.      File bn_create_net 
  69.  
  70. ***************************************************************************/
  71.  
  72. /*****************************************************************************
  73.   FUNCTION : bn_createPlanePanel
  74.  
  75.   PURPOSE  : creates the plane panel, which is part of the bignet-window
  76.   NOTES    :
  77.   RETURNS  :
  78.   UPDATE   : 20.12.1991
  79. ******************************************************************************/
  80.  
  81. static void bn_createPlanePannel (Widget parent)
  82.  
  83. {
  84.     Widget pannel;
  85.     Widget plane_edit,current_plane;
  86.     Widget plane_enter,plane_delete,plane_insert,plane_overwrite,plane_to_edit,type,pos;
  87.     Widget plane_first,plane_last,plane_prev,plane_next;
  88.     Widget       dummy;
  89.     Arg          arg[25];
  90.     Cardinal     n;
  91.     int colom1 = 25, colom2 = 13, colom3 = 10;
  92.  
  93.     n = 0;
  94.  
  95.     pannel = XtCreateManagedWidget ("pannel", formWidgetClass, parent, arg, n);
  96.  
  97.     z1s1 = ui_xCreateLabelItem ("           Plane           ", pannel, colom1 * bn_fontWidth, NULL, NULL);
  98.     z1s2 = ui_xCreateLabelItem ("Current Plane  ", pannel, colom2 * bn_fontWidth, z1s1, NULL);
  99.     z1s3 = ui_xCreateLabelItem ("Edit Plane  ", pannel, colom3 * bn_fontWidth, z1s2, NULL);
  100.  
  101.     z2s1   = ui_xCreateLabelItem ("Plane: ", pannel, colom1 * bn_fontWidth, NULL, z1s1);
  102.     dummy = ui_xCreateLabelItem (" ", pannel, 3 * bn_fontWidth, z2s1, z1s1);
  103.     z2s2   = ui_xCreateFrameLabelItem ("", pannel,bn_intWidth,dummy,z1s1);
  104.  
  105.     z3s1  = ui_xCreateLabelItem ("Type: ",pannel,colom1 * bn_fontWidth,NULL,z2s1);
  106.     dummy = ui_xCreateLabelItem (" ",pannel,3 * bn_fontWidth,z3s1,z2s1);
  107.     z3s2  = ui_xCreateFrameLabelItem ("",pannel,bn_intWidth,dummy,z2s1);
  108.     dummy = ui_xCreateLabelItem (" ",pannel,5 * bn_fontWidth,z3s2,z2s1);
  109.     z3s3  = ui_xCreateFrameLabelItem (plane_type[PLANE_type],pannel,bn_intWidth,dummy,z2s1);
  110.  
  111.     z4s1  = ui_xCreateLabelItem ("No. of units in x-direction: ",pannel,colom1 * bn_fontWidth,NULL,z3s1);
  112.     dummy = ui_xCreateLabelItem (" ", pannel, 3 * bn_fontWidth,z4s1,z3s1);
  113.     z4s2  = ui_xCreateFrameLabelItem ("", pannel,bn_intWidth,dummy,z3s1);
  114.     dummy = ui_xCreateLabelItem (" ", pannel, 5 * bn_fontWidth,z4s2,z3s1);
  115.     z4s3  = ui_xCreateDialogItem ("z4s3", pannel,"",bn_intWidth,dummy,z3s1);
  116.  
  117.     z5s1  = ui_xCreateLabelItem ("No. of units in y-direction: ",pannel,colom1 * bn_fontWidth,NULL,z4s1);
  118.     dummy = ui_xCreateLabelItem (" ", pannel, 3 * bn_fontWidth,z5s1,z4s1);
  119.     z5s2  = ui_xCreateFrameLabelItem ("", pannel,bn_intWidth,dummy,z4s1);
  120.     dummy = ui_xCreateLabelItem (" ", pannel, 5 * bn_fontWidth,z5s2,z4s1);
  121.     z5s3  = ui_xCreateDialogItem ("z4s3", pannel, "",bn_intWidth,dummy,z4s1);
  122.  
  123.     z6s1  = ui_xCreateLabelItem ("z-coordinates of the plane: ",pannel,colom1 * bn_fontWidth,NULL,z5s1);
  124.     dummy = ui_xCreateLabelItem (" ",pannel,3 * bn_fontWidth,z6s1,z5s1);
  125.     z6s2  = ui_xCreateFrameLabelItem ("", pannel,bn_intWidth,dummy,z5s1);
  126.     dummy = ui_xCreateLabelItem (" ",pannel,5 * bn_fontWidth,z6s2,z5s1);
  127.     z6s3  = ui_xCreateDialogItem ("z4s3",pannel,"",bn_intWidth,dummy,z5s1);
  128.  
  129.     z7s1  = ui_xCreateLabelItem ("Rel. Position: ",pannel,colom1 * bn_fontWidth,NULL,z6s1);
  130.     dummy = ui_xCreateLabelItem (" ",pannel,3 * bn_fontWidth,z7s1,z6s1);
  131.     z7s2  = ui_xCreateFrameLabelItem ("", pannel,bn_intWidth,dummy,z6s1);
  132.     dummy = ui_xCreateLabelItem (" ",pannel,5 * bn_fontWidth,z7s2,z6s1);
  133.     z7s3  = ui_xCreateFrameLabelItem (plane_pos[PLANE_pos],pannel,bn_intWidth,dummy,z6s1);
  134.  
  135.     dummy         = ui_xCreateLabelItem (" ",pannel,15 * bn_fontWidth,NULL,z7s1);
  136.  
  137.     plane_edit = ui_xCreateLabelItem ("Edit Plane: ",pannel,15 * bn_fontWidth,NULL,dummy);
  138.     plane_enter      = bn_basics_xCreateButtonItem ("enter",pannel,plane_edit,dummy);
  139.       XtAddCallback(plane_enter,XtNcallback,(XtCallbackProc)enter_plane_PROC,NULL);
  140.     plane_insert     = bn_basics_xCreateButtonItem ("insert",pannel,plane_enter,dummy);
  141.       XtAddCallback(plane_insert,XtNcallback,(XtCallbackProc)insert_plane_PROC,NULL);
  142.     plane_overwrite  = bn_basics_xCreateButtonItem ("overwrite",pannel,plane_insert,dummy);
  143.  
  144.       XtAddCallback(plane_overwrite,XtNcallback,(XtCallbackProc)overwrite_plane_PROC,NULL);
  145.     plane_delete     = bn_basics_xCreateButtonItem ("delete",pannel,plane_overwrite,dummy);
  146.       XtAddCallback(plane_delete,XtNcallback,(XtCallbackProc)delete_plane_PROC,NULL);
  147.  
  148.     dummy         = ui_xCreateLabelItem (" ",pannel,15 * bn_fontWidth,NULL,plane_edit);
  149.     plane_to_edit = bn_basics_xCreateButtonItem ("plane_to_edit",pannel,dummy,plane_edit);
  150.       XtAddCallback(plane_to_edit,XtNcallback,(XtCallbackProc)current_plane_to_editor_PROC,NULL);
  151.     type          = bn_basics_xCreateButtonItem ("type",pannel,plane_to_edit,plane_edit);
  152.       XtAddCallback(type,XtNcallback,(XtCallbackProc)type_PROC,NULL);
  153.     pos           = bn_basics_xCreateButtonItem ("pos",pannel,type,plane_edit);
  154.       XtAddCallback(pos,XtNcallback,(XtCallbackProc)pos_PROC,NULL);
  155.  
  156.     current_plane = ui_xCreateLabelItem ("Current plane: ",pannel,15 * bn_fontWidth,NULL,dummy);
  157.     plane_first         = bn_basics_xCreateButtonItem ("first",pannel,current_plane,dummy);
  158.       XtAddCallback(plane_first,XtNcallback,(XtCallbackProc)beginning_plane_PROC,NULL);
  159.     plane_prev          = bn_basics_xCreateButtonItem ("prev",pannel,plane_first,dummy);
  160.       XtAddCallback(plane_prev,XtNcallback,(XtCallbackProc)backward_plane_PROC,NULL);
  161.     plane_next          = bn_basics_xCreateButtonItem ("next",pannel,plane_prev,dummy);
  162.       XtAddCallback(plane_next,XtNcallback,(XtCallbackProc)forward_plane_PROC,NULL);
  163.     plane_last          = bn_basics_xCreateButtonItem ("last",pannel,plane_next,dummy);
  164.       XtAddCallback(plane_last,XtNcallback,(XtCallbackProc)end_plane_PROC,NULL);
  165. }
  166.  
  167.  
  168. /*****************************************************************************
  169.   FUNCTION : exit_PROC
  170.  
  171.   PURPOSE  : callback function of the exit-button. You are leaving bignet.
  172.   NOTES    :
  173.   RETURNS  :
  174.  
  175.   UPDATE   : 27.05.1993
  176. ******************************************************************************/
  177.  
  178. static void exit_PROC (void)
  179.  
  180. {
  181.     XtDestroyWidget (baseWidget);
  182.     bighop_widget_open = 0;
  183. }
  184. /* chris */
  185. /*****************************************************************************
  186.   FUNCTION : bn_createBigHop
  187.  
  188.   PURPOSE  : creates the bignet-window.
  189.   NOTES    : 
  190.   RETURNS  :
  191.  
  192.   UPDATE   : 27.05.1993
  193. ******************************************************************************/
  194.  
  195. void bn_createBigHop (void)
  196.  
  197. {
  198.     Widget       box;
  199.     Widget       create_net,exit,cancel;
  200.     Arg          arg[25];
  201.     Cardinal     n;
  202.     char         buf[40];
  203.  
  204.     if(! bighop_widget_open)
  205.       {
  206.        sprintf (buf, "BigNet (Hopfield)");
  207.        n = 0;  
  208.  
  209.        XtSetArg(arg[n],XtNminHeight,699); n++;
  210.        XtSetArg(arg[n],XtNminWidth,410); n++;  
  211.        XtSetArg(arg[n],XtNmaxHeight,699); n++;
  212.        XtSetArg(arg[n],XtNmaxWidth,410); n++;
  213.        
  214.  
  215.        baseWidget = XtCreatePopupShell (buf, topLevelShellWidgetClass, ui_toplevel, arg, n); 
  216.        n = 0;  
  217.        box = XtCreateManagedWidget ("box", boxWidgetClass, baseWidget, arg, n);
  218.        bn_createPlanePannel (box); 
  219.  
  220.        create_net = bn_basics_xCreateButtonItem ("create_net",box,NULL,NULL);
  221.          XtAddCallback(create_net,XtNcallback,(XtCallbackProc)create_net_PROC,NULL);
  222.        exit = bn_basics_xCreateButtonItem ("done",box,create_net,NULL);
  223.        XtAddCallback(exit,XtNcallback,(XtCallbackProc)exit_PROC,NULL);
  224.        cancel     = bn_basics_xCreateButtonItem ("cancel",box,exit,NULL);
  225.        XtAddCallback(cancel,XtNcallback,(XtCallbackProc)cancel_net_PROC,NULL);
  226.  
  227.        ui_checkWindowPosition(baseWidget);
  228.        XtPopup (baseWidget, XtGrabNone);
  229.        bighop_widget_open = 1;
  230.        if(PLANE_length != 0){
  231.          write_current_plane();
  232.          }
  233.  
  234.      } else {
  235.     
  236.         ui_confirmOk ("BigNet (Hopfield) already loaded");
  237.  
  238.      }
  239. }
  240.  
  241.  
  242.    
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250. /*************************************************************************
  251.  
  252.      File bn_create_net 
  253.  
  254. ***************************************************************************/
  255.  
  256.  
  257. /*****************************************************************************
  258.   FUNCTION : create__net_PROC
  259.  
  260.   PURPOSE  : creates a SNNS-net in two steps:
  261.              1. calls up a function, which creates SNNS-units
  262.              2. calls up a function, which connects the SNNS-units.
  263.   NOTES    : There is a full connection of the units! ( Clique ) 
  264.              
  265.   RETURNS  :
  266.  
  267.   UPDATE   : 27.05.1993
  268. ******************************************************************************/
  269.  
  270. static void create_net_PROC(void)
  271.  
  272. {
  273.  PLANE *source_plane,*target_plane;
  274.  int move;
  275.  int create=1;
  276.  
  277.  BN_ERROR = 0;
  278.  
  279.  if(krui_getNoOfUnits() != 0) {
  280.    if(! ui_confirmYes("Create will erase current network. Create?")) {
  281.      create = 0;
  282.    }
  283.  }
  284.  
  285.  if(create && (PLANE_length != 0)) {
  286.  
  287.    krui_deleteNet();
  288.  
  289.    calculate_first_snns_unit_no_of_plane();
  290.    create_snns_unit(); 
  291.    make_links();
  292.    krui_setLearnFunc("BPTT");
  293.    krui_setUpdateFunc("Hopfield_Synchronous");
  294.    krui_setInitialisationFunc("ClippHebb");
  295.    bn_display_net();
  296.  }/* if */ 
  297. }
  298.  
  299. /*****************************************************************************
  300.   FUNCTION : calculate_first_snns_unit_no_of_plane
  301.  
  302.   PURPOSE  : calculates the SNNS unit no of the left upper corner of every
  303.              plane.
  304.   NOTES    : relative to this unit no, knowing the width and the height of the
  305.              planes, all other SNNS unit numbers of every plane can be 
  306.              calculated. That's important for the function create_snns_unit.
  307.   RETURNS  :
  308.  
  309.   UPDATE   : 20.12.1991
  310. ******************************************************************************/
  311.  
  312. static void calculate_first_snns_unit_no_of_plane(void)
  313.  
  314. {
  315.  PLANE *PLANE_element = PLANE_first_element;
  316.  
  317.  (*PLANE_element).begin = 1;  
  318.  PLANE_element = (*PLANE_element).next;
  319.  
  320.  while(PLANE_element != NULL) {
  321.    (*PLANE_element).begin = (*(*PLANE_element).before).width *
  322.                                 (*(*PLANE_element).before).height +
  323.                   (*(*PLANE_element).before).begin;
  324.    PLANE_element = (*PLANE_element).next; 
  325.  }
  326. }
  327.  
  328.  
  329.  
  330. /*****************************************************************************
  331.   FUNCTION : calculate_x_begin
  332.  
  333.   PURPOSE  : calculates the x-coordinate of a plane, where the plane is
  334.              positioned in the display window.
  335.              plane.
  336.   NOTES    : 
  337.   RETURNS  : The X-Position
  338.  
  339.   UPDATE   : 20.12.1991
  340. ******************************************************************************/
  341.  
  342.  
  343. static int calculate_x_begin(int *new_x_begin,int *old_x_begin,int *x_max,int width,int pos)
  344.  
  345. {
  346.  if(pos == BN_RIGHT) {
  347.    
  348.    *new_x_begin = *x_max + 2; 
  349.    *x_max = *new_x_begin + width;
  350.    *old_x_begin = *new_x_begin;
  351.    return *new_x_begin;
  352.  }
  353.  else if(pos == BN_BELOW) {
  354.    if(*x_max < (*old_x_begin + width)) {
  355.      *x_max = *old_x_begin + width;
  356.    }
  357.    return *old_x_begin; 
  358.  }
  359.  else if(pos == BN_LEFT) {
  360.    *x_max = 0;
  361.    *old_x_begin = 2;
  362.  
  363.    *new_x_begin = *x_max + 2;
  364.    *x_max = *new_x_begin + width;
  365.    return *new_x_begin;
  366.  }
  367.  return 0;
  368. }
  369.  
  370.  
  371. /*****************************************************************************
  372.   FUNCTION : calculate_y_begin
  373.  
  374.   PURPOSE  : calculates the y-coordinate of a plane, where the plane is
  375.              positioned in the display window.
  376.              plane.
  377.  
  378.   NOTES    : 
  379.   RETURNS  : The Y-Position
  380.  
  381.   UPDATE   : 20.12.1991
  382. ******************************************************************************/
  383.  
  384. static int calculate_y_begin(int *absolute_y_max,int *relative_y_max,int *y_offset,int height,int pos)
  385.  
  386. {
  387. int y_begin;
  388.  
  389.  if(pos == BN_RIGHT) {
  390.    y_begin = *y_offset + 2;         
  391.    *relative_y_max = y_begin + height;
  392.    if(*absolute_y_max < *relative_y_max) {
  393.      *absolute_y_max = *relative_y_max;
  394.    }
  395.  }
  396.  else if(pos == BN_BELOW) {
  397.    y_begin = *relative_y_max + 2;   
  398.    *relative_y_max = y_begin + height;
  399.    if(*absolute_y_max < *relative_y_max) {
  400.      *absolute_y_max = *relative_y_max;
  401.    }
  402.  }
  403.  else if(pos == BN_LEFT) {
  404.    *y_offset = *absolute_y_max;
  405.    y_begin = *y_offset + 2;
  406.    *absolute_y_max = y_begin + height;
  407.    *relative_y_max = y_begin + height;
  408.  }
  409.  return y_begin;
  410. }
  411.  
  412.  
  413. /*****************************************************************************
  414.   FUNCTION : create_snns_unit
  415.  
  416.   PURPOSE  : creates for every unit of a plane a SNNS  unit.
  417.  
  418.   NOTES    : Default unit with Step - activation function
  419.   RETURNS  :
  420.  
  421.   UPDATE   : 20.12.1991
  422. ******************************************************************************/
  423.  
  424. static void create_snns_unit(void)
  425.  
  426. {
  427.  struct PosType unit_pos;
  428.  
  429.  PLANE *PLANE_element = PLANE_first_element; 
  430.  int x,y,width,height,unit_no,pos,ret;
  431.  int y_offset=0,relative_y_max=0,absolute_y_max=0,y_begin;
  432.  int x_max=0,old_x_begin=2,new_x_begin,x_begin;
  433.  
  434.  ret = krui_allocateUnits((*PLANE_last_element).width * 
  435.                              (*PLANE_last_element).height +
  436.                                (*PLANE_last_element).begin-1);
  437.  if(ret != 0){
  438.    ui_tw_errorMessage(krui_error(ret));
  439.    BN_ERROR = 1;
  440.  }
  441.  
  442.  while((! BN_ERROR) && (PLANE_element != NULL)) {
  443.  
  444.    height = (*PLANE_element).height;
  445.    width  = (*PLANE_element).width;
  446.    pos    = (*PLANE_element).pos;
  447.     
  448.    y_begin = calculate_y_begin(&absolute_y_max,&relative_y_max,&y_offset,height,pos);
  449.    x_begin = calculate_x_begin(&new_x_begin,&old_x_begin,&x_max,width,pos);
  450.  
  451.    for(y=0;y<height;y++){
  452.      for(x=0;x<width;x++){
  453.        unit_no = krui_createDefaultUnit();
  454.        if(unit_no<0) ui_checkError(unit_no);
  455.        krui_setUnitActFunc(unit_no, "Act_Perceptron");
  456.        ret = krui_setUnitTType(unit_no,(*PLANE_element).type+1);
  457.        if(ret != 0){
  458.          ui_tw_errorMessage(krui_error(ret));
  459.          BN_ERROR = 1;
  460.        }
  461.       
  462.        unit_pos.x = x_begin + x;
  463.        unit_pos.y = y_begin + y;
  464.  
  465.        krui_setUnitPosition(unit_no,&unit_pos);
  466.      }/*for*/
  467.    }/*for*/
  468.  
  469.    PLANE_element = (*PLANE_element).next;
  470.  }/*while*/
  471. }
  472.  
  473.  
  474. /*****************************************************************************
  475.   FUNCTION : make_links
  476.  
  477.   PURPOSE  : Insert Links between all units, that they form a
  478.              clique, i.e. every unit is connected to all other units.
  479.   RETURNS  : alteration of the network
  480.   NOTES    :
  481.  
  482.   UPDATE   :
  483. *****************************************************************************/
  484.  
  485. static void make_links(void)
  486.  
  487. {
  488.   int                     unit_ptr, mainUnit_Ptr;
  489.   FlintType               weight;
  490.   
  491.   
  492.   
  493.   weight = 1.0;
  494.   
  495.   for ((mainUnit_Ptr) = krui_getFirstUnit();
  496.        (mainUnit_Ptr) <= krui_getNoOfUnits(); (mainUnit_Ptr)++)
  497.     
  498.     /* main loop  self connections too  */
  499.     
  500.     for ((unit_ptr) =  krui_getFirstUnit();
  501.      (unit_ptr) <= krui_getNoOfUnits(); (unit_ptr)++) { 
  502.       
  503.       
  504.       /* inner loop */
  505.       /*if (NOT (unit_ptr == mainUnit_Ptr)) {  not the same entry !! */
  506.       
  507.       krui_setCurrentUnit(mainUnit_Ptr);
  508.       if (NOT krui_isConnected(unit_ptr)) {
  509.     krui_createLink(unit_ptr, weight);
  510.     krui_setLinkWeight(weight); 
  511.     
  512.       }
  513.     }
  514. }
  515.  
  516.  
  517. /*****************************************************************************
  518.   FUNCTION : bn_display_net
  519.  
  520.   PURPOSE  : displays the created net in the display window of SNNS.
  521.  
  522.   NOTES    : 
  523.   RETURNS  :
  524.  
  525.   UPDATE   : 20.12.1991
  526. ******************************************************************************/
  527.  
  528. static void bn_display_net(void)
  529.  
  530. {
  531.  ui_sel_resetList();
  532.  ui_net_completeRefresh(ui_currentDisplay,2);
  533.  ui_stat_displayStatus(ui_gridPosMouse);
  534.  strcpy(ui_filenameNET,"SNNS_NET");
  535.  strcpy(ui_filenameSLNET,"SNNS_NET");
  536.  ui_file_updateShellLabels();
  537. }
  538.  
  539. /*****************************************************************************
  540.  
  541.   bn_plane
  542.   PURPOSE  : Functions of the plane editor.
  543.  
  544. ******************************************************************************/
  545.  
  546.  
  547. /*****************************************************************************
  548.   FUNCTION : read_plane_elements
  549.  
  550.   PURPOSE  : reads the input datas of the plane editor (Edit Plane).
  551.  
  552.   NOTES    : 
  553.  
  554.   RETURNS  :  Error = 0 ; Succes = 1
  555.  
  556.   UPDATE   : 20.12.1991
  557. ******************************************************************************/
  558.  
  559. static int read_plane_elements(void)
  560.  
  561. {
  562.  PLANE_width = ui_xIntFromAsciiWidget(z4s3);
  563.  PLANE_height = ui_xIntFromAsciiWidget(z5s3);
  564.  if((PLANE_width > 0) && (PLANE_height > 0)) {
  565.    return 1;
  566.  }
  567.  else {
  568.    return 0;
  569.  }
  570. }
  571.   
  572. /*****************************************************************************
  573.   FUNCTION : write_current_plane
  574.  
  575.   PURPOSE  : writes the datas of the current_element to the control part 
  576.              (Current Plane) of the plane editor.
  577.  
  578.   NOTES    : 
  579.   RETURNS  : 
  580.  
  581.   UPDATE   : 20.12.1991
  582. ******************************************************************************/
  583.  
  584. static void write_current_plane(void)
  585.  
  586.  {
  587.   char buf[10];
  588.  
  589.   sprintf(buf,"%d",PLANE_no);
  590.   ui_xSetLabel(z2s2,bn_widget_output(buf));
  591.   ui_xSetLabel(z3s2,plane_type[(*PLANE_current_element).type]);
  592.   sprintf(buf,"%d",(*PLANE_current_element).width);
  593.   ui_xSetLabel(z4s2,bn_widget_output(buf));
  594.   sprintf(buf,"%d",(*PLANE_current_element).height);
  595.   ui_xSetLabel(z5s2,bn_widget_output(buf));
  596.   sprintf(buf,"%d",0);
  597.   ui_xSetLabel(z6s2,bn_widget_output(buf));
  598.   ui_xSetLabel(z7s2,plane_pos[(*PLANE_current_element).pos]);
  599. }
  600.  
  601. /*****************************************************************************
  602.   FUNCTION : clear_current_plane
  603.  
  604.   PURPOSE  : Deletes the datas standing in Current Plane.
  605.  
  606.   NOTES    : 
  607.   RETURNS  :
  608.  
  609.   UPDATE   : 20.12.1991
  610. ******************************************************************************/
  611.  
  612. static void clear_current_plane(void)
  613.  
  614.  {
  615.   ui_xSetLabel(z2s2,"");
  616.   ui_xSetLabel(z3s2,"");
  617.   ui_xSetLabel(z4s2,"");
  618.   ui_xSetLabel(z5s2,"");
  619.   ui_xSetLabel(z6s2,"");
  620.   ui_xSetLabel(z7s2,"");
  621. }
  622.  
  623. /*****************************************************************************
  624.   FUNCTION : write_current_plane_to_editor
  625.  
  626.   PURPOSE  : writes the datas of Current Plane to Edit Plane
  627.  
  628.   NOTES    : 
  629.   RETURNS  :
  630.  
  631.   UPDATE   : 20.12.1991
  632. ******************************************************************************/
  633.  
  634. static void write_current_plane_to_editor(void)
  635.  
  636.  {
  637.   char buf[10];
  638.  
  639.   PLANE_type = (*PLANE_current_element).type;
  640.   ui_xSetLabel(z3s3,plane_type[PLANE_type]);
  641.   sprintf(buf,"%d",(*PLANE_current_element).width);
  642.   ui_xSetString(z4s3,bn_widget_output(buf));
  643.   sprintf(buf,"%d",(*PLANE_current_element).height);
  644.   ui_xSetString(z5s3,bn_widget_output(buf));
  645.   sprintf(buf,"%d",0);
  646.   ui_xSetString(z6s3,bn_widget_output(buf));
  647.   PLANE_pos = (*PLANE_current_element).pos;
  648.   ui_xSetLabel(z7s3,plane_pos[PLANE_pos]);
  649. }
  650.  
  651. /*****************************************************************************
  652.   FUNCTION : clear_edit_plane
  653.  
  654.   PURPOSE  : Deletes the datas standing in Edit Link.
  655.  
  656.   NOTES    : 
  657.   RETURNS  :
  658.  
  659.   UPDATE   : 20.12.1991
  660. ******************************************************************************/
  661.  
  662. static void clear_edit_plane(void)
  663.  
  664. {
  665.  ui_xSetString(z4s3,"");
  666.  ui_xSetString(z5s3,"");
  667.  ui_xSetString(z6s3,"");
  668. } 
  669.  
  670.  
  671. /*****************************************************************************
  672.   FUNCTION : cancel_net_PROC
  673.  
  674.   PURPOSE  : callback function, which deletes all the datas in the link 
  675.              editor and in the plane editor.
  676.  
  677.   NOTES    : 
  678.   RETURNS  :
  679.  
  680.   UPDATE   : 20.12.1991
  681. ******************************************************************************/
  682.  
  683. static void cancel_net_PROC(void)
  684.  
  685. {
  686.  while(PLANE_length){
  687.   delete_current_plane();
  688.  }
  689.  clear_current_plane();
  690. }
  691.  
  692. /*****************************************************************************
  693.   FUNCTION : enter_plane_PROC
  694.  
  695.   PURPOSE  : callback function, which enters a plane element at the end of the 
  696.              plane list.
  697.  
  698.   NOTES    : the plane list contains all datas entered by the plane editor.
  699.              Every plane element is a struct (see bn_types.c)
  700.   RETURNS  :
  701.  
  702.   UPDATE   : 20.12.1991
  703. ******************************************************************************/
  704.  
  705. static void enter_plane_PROC(void)
  706.  
  707. {
  708.  if(read_plane_elements()){
  709.    enter_plane();
  710.    write_current_plane();
  711.    clear_edit_plane();
  712.  }
  713. }
  714.  
  715. /*****************************************************************************
  716.   FUNCTION : insert_plane_PROC
  717.  
  718.   PURPOSE  : callback function, which inserts the the input datas of the
  719.              plane editor (Edit Plane) in front of Current Plane.
  720.  
  721.   NOTES    : 
  722.   RETURNS  :
  723.  
  724.   UPDATE   : 20.12.1991
  725. ******************************************************************************/
  726.  
  727. static void insert_plane_PROC(void)
  728.  
  729. {
  730.  if(read_plane_elements()) {
  731.    insert_plane();
  732.    write_current_plane();
  733.    clear_edit_plane();
  734. /*   if(LINK_length == 0) {
  735.      clear_current_link();
  736.    }
  737.    else {
  738.      write_current_link();
  739.    }
  740. */
  741.  }
  742. }
  743.  
  744. /*****************************************************************************
  745.   FUNCTION : overwrite_plane_PROC
  746.  
  747.   PURPOSE  : callback function, which overwrites the current plane element
  748.              (Current Plane) with the datas of the plane editor (Edit plane).
  749.  
  750.   NOTES    : 
  751.   RETURNS  :
  752.  
  753.   UPDATE   : 20.12.1991
  754. ******************************************************************************/
  755.  
  756. static void overwrite_plane_PROC(void)
  757.  
  758. {
  759.  if(read_plane_elements()) {
  760.   overwrite_plane();
  761.   write_current_plane();
  762.   clear_edit_plane();
  763. /*  if(LINK_length == 0) {
  764.     clear_current_link();
  765.   }
  766.   else {
  767.     write_current_link();
  768.   }
  769. */
  770.  }
  771. }
  772.  
  773. /*****************************************************************************
  774.   FUNCTION : delete_plane_PROC
  775.  
  776.   PURPOSE  : callback function, which deletes the Currenrt Plane out of
  777.              the plane list.
  778.  
  779.   NOTES    : 
  780.   RETURNS  :
  781.  
  782.   UPDATE   : 20.12.1991
  783. ******************************************************************************/
  784.  
  785. static void delete_plane_PROC(void)
  786.  
  787. {
  788.  delete_current_plane();
  789.  if(PLANE_length == 0) {
  790.    clear_current_plane();
  791.  }
  792.  else {
  793.    write_current_plane();
  794.  }
  795. /* if(LINK_length == 0) {
  796.    clear_current_link();
  797.  }
  798.  else {
  799.   write_current_link();
  800.  }
  801. */
  802. }
  803.  
  804. /*****************************************************************************
  805.   FUNCTION : forward_plane_PROC
  806.  
  807.   PURPOSE  : callback function, which moves forward one list element in the
  808.              plane list.
  809.  
  810.   NOTES    : 
  811.   RETURNS  :
  812.  
  813.   UPDATE   : 20.12.1991
  814. ******************************************************************************/
  815.  
  816. static void forward_plane_PROC(void)
  817.  
  818. {
  819.  if(forward_plane()){
  820.    write_current_plane();
  821.  }
  822. }
  823.  
  824. /*****************************************************************************
  825.   FUNCTION : backward_plane_PROC
  826.  
  827.   PURPOSE  : callback function, which moves backward one list element in the
  828.              plane list.
  829.  
  830.   NOTES    : 
  831.   RETURNS  :
  832.  
  833.   UPDATE   : 20.12.1991
  834. ******************************************************************************/
  835.  
  836. static void backward_plane_PROC(void)
  837.  
  838. {
  839.  if(backward_plane()) {
  840.    write_current_plane();
  841.  }
  842. }
  843.  
  844. /*****************************************************************************
  845.   FUNCTION : end_plane_PROC
  846.  
  847.   PURPOSE  : callback function, which jumps to the end of the plane list.
  848.  
  849.   NOTES    : 
  850.   RETURNS  :
  851.  
  852.   UPDATE   : 20.12.1991
  853. ******************************************************************************/
  854.  
  855. static void end_plane_PROC(void)
  856.  
  857. {
  858.  if(end_plane()) {
  859.    write_current_plane();
  860.  }
  861. }
  862.  
  863. /*****************************************************************************
  864.   FUNCNCTION : beginning_plane_PROC
  865.  
  866.   PURPOSE  : callback function, which jumps to the beginning of the plane list.
  867.  
  868.   NOTES    : 
  869.   RETURNS  :
  870.  
  871.   UPDATE   : 20.12.1991
  872. ******************************************************************************/
  873.  
  874. static void beginning_plane_PROC(void)
  875.  
  876. {
  877.  if(beginning_plane()) {
  878.    write_current_plane();
  879.  }
  880. }
  881.  
  882. /*****************************************************************************
  883.   FUNCNCTION : pos_PROC
  884.  
  885.   PURPOSE  : callback function, which defines the position of the plane in the
  886.              display window.
  887.  
  888.   NOTES    : 
  889.   RETURNS  :
  890.  
  891.   UPDATE   : 20.12.1991
  892. ******************************************************************************/
  893.  
  894. static void pos_PROC(void)
  895.  
  896. {
  897.  if(PLANE_pos == BN_RIGHT) {
  898.    PLANE_pos = BN_BELOW;
  899.  }
  900.  else if(PLANE_pos == BN_BELOW) {
  901.    PLANE_pos = BN_LEFT;
  902.  } 
  903.  else {
  904.    PLANE_pos = BN_RIGHT;
  905.  }
  906.  ui_xSetLabel(z7s3,plane_pos[PLANE_pos]);
  907. }
  908.  
  909. /*****************************************************************************
  910.   FUNCNCTION : current_plane_to_editor_PROC
  911.  
  912.   PURPOSE  : callback function, which writes the Current Plane to Edit Plane
  913.  
  914.   NOTES    : 
  915.   RETURNS  :
  916.  
  917.   UPDATE   : 20.12.1991
  918. ******************************************************************************/
  919.  
  920. static void current_plane_to_editor_PROC(void)
  921.  
  922. {
  923.  if(PLANE_length != 0) {
  924.    write_current_plane_to_editor();
  925.  }
  926.  else {
  927.    clear_edit_plane();
  928.  }
  929. }
  930.  
  931. /*****************************************************************************
  932.   FUNCNCTION : type_PROC
  933.  
  934.   PURPOSE  : callback function, which defines the unit type of a plane.
  935.  
  936.   NOTES    : 
  937.   RETURNS  :
  938.  
  939.   UPDATE   : 20.12.1991
  940. ******************************************************************************/
  941.  
  942. static void type_PROC(void)
  943.  
  944. {
  945.  switch(PLANE_type){
  946.    case BN_INPUT : {PLANE_type = BN_HIDDEN; break;}
  947.    case BN_HIDDEN: {PLANE_type = BN_OUTPUT; break;}
  948.    case BN_OUTPUT: {PLANE_type = BN_INPUT ; break;}
  949.    case BN_DUAL:   {PLANE_type = BN_DUAL  ; break;}  
  950.  }
  951.  ui_xSetLabel(z3s3,plane_type[PLANE_type]);
  952. }
  953.  
  954. /*****************************************************************************
  955.   FUNCTION : enter_plane
  956.  
  957.   PURPOSE  : enters a plane element at the end of the plane list.
  958.  
  959.   NOTES    : 
  960.   RETURNS  :
  961.  
  962.   UPDATE   : 20.12.1991
  963. ******************************************************************************/
  964.  
  965. static void enter_plane(void)
  966.  
  967. {
  968.  PLANE *PLANE_element;
  969.  
  970.  PLANE_element = (PLANE *)malloc(sizeof(PLANE));
  971.  (*PLANE_element).width      = PLANE_width;                                    
  972.  (*PLANE_element).height      = PLANE_height;
  973.  (*PLANE_element).pos    = PLANE_pos;
  974.  (*PLANE_element).type   = PLANE_type;                                    
  975.  (*PLANE_element).next   = NULL;                            
  976.  (*PLANE_element).before = PLANE_last_element;         
  977.  
  978.  if(PLANE_last_element != NULL) {
  979.    (*PLANE_last_element).next = PLANE_element;
  980.  }
  981.  
  982.  if(PLANE_first_element == NULL) {
  983.    PLANE_first_element = PLANE_element;
  984.  }
  985.  
  986.  PLANE_last_element = PLANE_element;
  987.  PLANE_current_element = PLANE_last_element;
  988.  
  989.  PLANE_no = ++PLANE_length;
  990. }/* enter_plane */
  991.  
  992. /*****************************************************************************
  993.   FUNCTION : insert_plane
  994.  
  995.   PURPOSE  : inserts the the input datas of the plane editor (Edit Plane) in 
  996.              front of Current Plane.
  997.  
  998.   NOTES    : 
  999.   RETURNS  :
  1000.  
  1001.   UPDATE   : 20.12.1991
  1002. ******************************************************************************/
  1003.  
  1004. static void insert_plane(void)
  1005.  
  1006. {
  1007.  PLANE *PLANE_element;
  1008.  
  1009.  if(PLANE_length == 0) {
  1010.    enter_plane();
  1011.  }
  1012.  else {
  1013.    PLANE_element = (PLANE *)malloc(sizeof(PLANE));
  1014.    
  1015.    (*PLANE_element).width      = PLANE_width;                                    
  1016.    (*PLANE_element).height      = PLANE_height;
  1017.    (*PLANE_element).pos    = PLANE_pos;
  1018.    (*PLANE_element).type   = PLANE_type;                                    
  1019.    (*PLANE_element).next   = PLANE_current_element;                            
  1020.    (*PLANE_element).before = (*PLANE_current_element).before;
  1021.  
  1022.    if((*PLANE_current_element).before != 0) {
  1023.      (*(*PLANE_current_element).before).next = PLANE_element;
  1024.    }
  1025.    (*PLANE_current_element).before = PLANE_element;         
  1026.  
  1027.    PLANE_current_element = PLANE_element;
  1028.    
  1029.    if((*PLANE_element).before == NULL) {
  1030.      PLANE_first_element = PLANE_element;
  1031.    } 
  1032.  
  1033.    PLANE_length++;
  1034. /*
  1035.    LINK_current_element = LINK_first_element; 
  1036.  
  1037.    while(LINK_current_element) {
  1038.      if((*LINK_current_element).SOURCE.plane >= PLANE_no) {
  1039.        (*LINK_current_element).SOURCE.plane++;
  1040.      }
  1041.      if((*LINK_current_element).TARGET.plane >= PLANE_no) {
  1042.        (*LINK_current_element).TARGET.plane++;
  1043.      }
  1044.      LINK_current_element = (*LINK_current_element).next;
  1045.    }
  1046.  
  1047.    LINK_current_element = LINK_last_element;
  1048. */
  1049.  }
  1050. }
  1051.  
  1052. /*****************************************************************************
  1053.   FUNCTION : overwrite_plane
  1054.  
  1055.   PURPOSE  : overwrites the current plane element (Current Plane) with the 
  1056.              datas of the plane editor (Edit Plane).
  1057.  
  1058.   NOTES    : 
  1059.   RETURNS  :
  1060.  
  1061.   UPDATE   : 20.12.1991
  1062. ******************************************************************************/
  1063.  
  1064. static void overwrite_plane(void)
  1065.  
  1066. {
  1067.  if(PLANE_length == 0) {
  1068.    enter_plane();
  1069.  }
  1070.  else {
  1071.    (*PLANE_current_element).width = PLANE_width;
  1072.    (*PLANE_current_element).height = PLANE_height;
  1073.    (*PLANE_current_element).pos = PLANE_pos;
  1074.    (*PLANE_current_element).type = PLANE_type;
  1075.  
  1076. /*   get_links_and_delete_them(PLANE_no);
  1077.  
  1078.    LINK_current_element = LINK_first_element;
  1079. */
  1080.  }
  1081. }
  1082.  
  1083. /*****************************************************************************
  1084.   FUNCTION : delete_current_plane
  1085.  
  1086.   PURPOSE  : deletes Currenrt Plane out of the plane list.
  1087.  
  1088.   NOTES    : 
  1089.   RETURNS  :
  1090.  
  1091.   UPDATE   : 20.12.1991
  1092. ******************************************************************************/
  1093.  
  1094. static void delete_current_plane(void)
  1095.  
  1096. {
  1097.  PLANE *PLANE_element;
  1098.  
  1099.  PLANE_element = PLANE_current_element;
  1100.  
  1101.  /* Delete the element "PLANE_element" out of the plane-list */
  1102.  
  1103.  if(PLANE_length != 0) {
  1104.    if((*PLANE_element).before != NULL) {
  1105.      (*(*PLANE_element).before).next = (*PLANE_element).next;
  1106.    }
  1107.    if((*PLANE_element).next != NULL) {
  1108.      (*(*PLANE_element).next).before = (*PLANE_element).before;
  1109.    }
  1110.  
  1111.    /* Delete all the links which are connected with the deleted plane */
  1112.    
  1113. /*   get_links_and_delete_them(PLANE_no);
  1114.  
  1115.    LINK_current_element = LINK_first_element;
  1116. */
  1117.    /* Decrement the number of the Planes */
  1118.  
  1119. /*   while(LINK_current_element) {
  1120.      if((*LINK_current_element).SOURCE.plane > PLANE_no) {
  1121.        (*LINK_current_element).SOURCE.plane--;
  1122.      }
  1123.      if((*LINK_current_element).TARGET.plane > PLANE_no) {
  1124.        (*LINK_current_element).TARGET.plane--;
  1125.      }
  1126.      LINK_current_element = (*LINK_current_element).next;
  1127.    }
  1128.  
  1129.    LINK_current_element = LINK_last_element;
  1130. */
  1131.    PLANE_length--;
  1132.  
  1133.    /* Update the three pointers "PLANE_current_element", "PLANE_first_element"
  1134.       "PLANE_last_element."  */
  1135.  
  1136.    if(PLANE_length == 0){
  1137.      PLANE_current_element = NULL;
  1138.      PLANE_first_element   = NULL;
  1139.      PLANE_last_element    = NULL;
  1140.      PLANE_no--;
  1141.    }
  1142.    else if((*PLANE_element).next == NULL) {
  1143.      PLANE_current_element = (*PLANE_element).before;
  1144.      PLANE_last_element    = PLANE_current_element;
  1145.      PLANE_no--;
  1146.    }
  1147.    else if((*PLANE_element).before == NULL) {
  1148.      PLANE_current_element = (*PLANE_element).next;
  1149.      PLANE_first_element   = PLANE_current_element;
  1150.    }
  1151.    else {
  1152.      PLANE_current_element = (*PLANE_element).next;
  1153.    }
  1154.  
  1155.    free(PLANE_element);
  1156.  }
  1157. }
  1158.  
  1159. /*****************************************************************************
  1160.   FUNCTION : forward_plane
  1161.  
  1162.   PURPOSE  : moves forward one list element in the plane list.
  1163.  
  1164.   NOTES    : 
  1165.   RETURNS  : Error = 0 ; Succes = 1
  1166.  
  1167.   UPDATE   : 20.12.1991
  1168. ******************************************************************************/
  1169.  
  1170. static int forward_plane(void)
  1171.  
  1172. {
  1173.  if(PLANE_length != 0) {
  1174.    if((*PLANE_current_element).next != NULL) {
  1175.      PLANE_current_element = (*PLANE_current_element).next;
  1176.      PLANE_no++;
  1177.    }
  1178.    return 1;
  1179.  }
  1180.  else {
  1181.   return 0;
  1182.  }
  1183. }
  1184.  
  1185. /*****************************************************************************
  1186.   FUNCTION : backward_link
  1187.  
  1188.   PURPOSE  : moves backward one plane element in the link list.
  1189.  
  1190.   NOTES    : 
  1191.   RETURNS  : Error = 0 ; Succes = 1
  1192.  
  1193.   UPDATE   : 20.12.1991
  1194. ******************************************************************************/
  1195.  
  1196. static int backward_plane(void)
  1197.  
  1198. {
  1199.  if(PLANE_length != 0) {
  1200.    if((*PLANE_current_element).before != NULL) {
  1201.      PLANE_current_element = (*PLANE_current_element).before;
  1202.      PLANE_no--;
  1203.    }
  1204.    return 1;
  1205.  }
  1206.  else {
  1207.    return 0;
  1208.  }
  1209. }
  1210.  
  1211. /*****************************************************************************
  1212.   FUNCTION : beginning_plane
  1213.  
  1214.   PURPOSE  : jumps to the beginning of the plane list.
  1215.  
  1216.   NOTES    : 
  1217.   RETURNS  : Error = 0 ; Succes = 1
  1218.  
  1219.   UPDATE   : 20.12.1991
  1220. ******************************************************************************/
  1221.  
  1222. static int beginning_plane(void)
  1223.  
  1224. {
  1225.  if(PLANE_length != 0){
  1226.    PLANE_current_element = PLANE_first_element;
  1227.    PLANE_no = 1;
  1228.    return 1;
  1229.  }
  1230.  else {
  1231.   return 0;
  1232.  }
  1233. }
  1234.  
  1235. /*****************************************************************************
  1236.   FUNCTION : end_plane
  1237.  
  1238.   PURPOSE  : jumps to the end of the plane list.
  1239.  
  1240.   NOTES    : 
  1241.   RETURNS  : Error = 0 ; Succes = 1
  1242.  
  1243.   UPDATE   : 20.12.1991
  1244. ******************************************************************************/
  1245.  
  1246. static int end_plane(void)
  1247.  
  1248. {
  1249.  if(PLANE_length != 0) {
  1250.    PLANE_current_element = PLANE_last_element;
  1251.    PLANE_no = PLANE_length;
  1252.    return 1;
  1253.  }
  1254.  else {
  1255.    return 0;
  1256.  }
  1257. }
  1258.  
  1259. /*****************************************************************************
  1260.   FUNCTION : get_plane
  1261.  
  1262.   PURPOSE  : returns a pointer to the plane element "plane_no"
  1263.  
  1264.   NOTES    : 
  1265.   RETURNS  : returns a pointer to the plane element "plane_no" 
  1266.  
  1267.   UPDATE   : 20.12.1991
  1268. ******************************************************************************/
  1269.  
  1270. static PLANE *get_plane(int plane_no)
  1271.  
  1272. {
  1273.  PLANE *PLANE_element = PLANE_first_element;
  1274.  int counter = 1;
  1275.  
  1276.  while((PLANE_element != NULL) &&
  1277.        (counter != plane_no)) {
  1278.    counter++;
  1279.    PLANE_element = (*PLANE_element).next;
  1280.           
  1281.  }/*while*/
  1282.  return PLANE_element;
  1283. }/*get_plane*/
  1284.  
  1285.  
  1286. /*****************************************************************************
  1287.  
  1288. ******************************************************************************/
  1289.  
  1290. /* end of file */
  1291. /* lines: 2710 */
  1292.  
  1293.  
  1294.  
  1295.